// @ts-nocheck==
import { reactive, ref, onMounted, onUnmounted, watch, nextTick } from "vue"
import { useDebounceFn } from "@vueuse/core"

import useApi from "@/api/use增查api"
import * as util from "@/utils"
import { 提示enum } from "amtf/utils"
import { ElMessage, ElMessageBox } from "element-plus"
import use路由 from "@/hooks/use路由"
import { use快捷键 } from "amtf/hooks/use快捷键"
import use元件袋 from "@/hooks/use元件袋"

export default function (cfg = {}): 详情 {
    const 元件袋 = use元件袋({ 字段设置集: cfg.字段设置集 })
    // 元件袋.取组件()

    // const 子表ref = cfg.子表ref
    // console.log(`子表ref 👉`, 子表ref)
    const a = reactive({
        变化了: false,
        已熟: false,
    })
    // const 变化了 = ref(false)
    let 监听变化 = true

    const 单项 = reactive({})
    const 弹窗否 = ref(false)
    const formRef = ref(false)
    const api = useApi(cfg.url)
    const 路由 = use路由()

    let 源单项: 单项
    const 初始化 = async () => {
        console.log(`初始化 ing👇`)
        // a.变化了 = false
        // 监听变化 = false
        const id = 路由.currentRoute.query.id
        const res = await api.查({ id })
        console.log(`详情 查 res 👉`, res)
        if (res.code === 0) {
            util.对象重予(单项, res.data)
            源单项 = util.深拷贝(res.data)
            if (cfg.展示前处理) {
                // console.log(`单项 👉`,单项)
                cfg.展示前处理(单项)
            }
            元件袋.取候选值集()
            元件袋.查外键关联字段集(单项)
            a.已熟 = true
            await nextTick();
            a.变化了 = false
        }
        // 监听变化 = true
    }
    初始化()

    // const 外键关联字段集 = reactive({})
    // const 外键组 = cfg.外键组 ? cfg.外键组 : []
    // 外键组.push({ 字段名: "创建者", })
    // 外键组.push({ 字段名: "更新者", })
    // for (const 外键 of 外键组) {
    //     // 予初始值,防止vue模板报错
    //     外键关联字段集[外键.字段名] = {}
    // }

    // async function 查外键关联字段集(params) {
    //     if (!外键组) return
    //     for (const 外键 of 外键组) {
    //         // 前面的 字段名 是简称，go中实际字段名加了 id
    //         let 实际字段名 = 外键.字段名
    //         if (!util.含其中之一(外键.字段名, ['创建者', '更新者'])) {
    //             实际字段名 = 外键.字段名 + 'id'
    //         }
    //         let id = 单项[实际字段名]
    //         外键.id = `${id}`
    //     }
    //     const res = await api.查外键关联字段集({ 外键组: JSON.stringify(外键组) })
    //     console.log(`查外键关联字段集res 👉`, res)
    //     if (res.code === 0) {
    //         util.对象重予(外键关联字段集, res.data)
    //     }
    // }
    // 查外键关联字段集()

    const 新增子级 = 父级id => {
        let 单项模板 = 元件袋.取元件单项模板()
        单项模板.父级id = 父级id
        util.对象重予(单项, 单项模板)
        弹窗否.value = true
    }

    const 复制 = (单项a = 单项) => {
        console.log(`复制 单项a 👉`, 单项a)
        监听变化 = false
        let 单项模板 = util.深拷贝(单项a)
        单项模板.id = 0
        util.对象重予(单项, 单项模板)
        if (cfg.复制后处理) {
            cfg.复制后处理(单项)
        }
        弹窗否.value = true
        // 监听变化 = true
    }

    const 保存 = async () => {
        if (!a.变化了) return
        let res0 = false
        await formRef.value?.validate(async (valid, fields) => {
            // console.log(`fields 👉`, fields)
            // console.log(`valid 👉`, valid)
            if (!valid) {
                util.提示(提示enum.出错, '内容不符合要求 ')
                res0 = false
                return
            }

            // console.log(`单项 👉`, 单项)
            if (cfg.保存前处理) {
                // console.log(`单项 👉`,单项)
                cfg.保存前处理(单项)
            }
            // return
            let res
            if (!单项.id || 单项.id < 0) {
                res = await api.增(单项)
            } else {
                // const 变动单项 = util.取变动单项(源单项, 单项)
                res = await api.改(单项)
            }
            if (res.code === 0) {
                util.提示()
                初始化()
            }
            res0 = true
        }).catch(({ errors, fields }) => {
            console.log(`errors 👉`, errors)
            res0 = false
        })
        return res0
    }

    const 流程动作 = async (动作名称: string) => {
        if (a.变化了) {
            let res = await 保存()
            console.log(`保存 res 👉`, res)
            if (!res) {
                return false
            }
        }
        let res = await api.改({ id: 单项.id, 动作: 动作名称 })
        if (res.code === 0) {
            util.提示()
            初始化()
        }
    }

    const 删 = async () => {
        ElMessageBox.confirm("确定要删除吗?", "提示", {
            confirmButtonText: "确定",
            cancelButtonText: "取消",
            type: "warning",
        })
            .then(async () => {
                const res = await api.删({ id: 单项.id })
                if (res.code === 0) {
                    util.提示(提示enum.成功, '删除成功', "删除")
                    // 关闭tab，待续……
                }
            })
            .catch(() => { })
    }

    const 快捷键cfg: 快捷键cfg = {
        ctrl_s: event => {
            event.preventDefault()
            console.log(`保存 ing👇`)
            保存()
        },
    }
    const 快捷键 = use快捷键(快捷键cfg)

    // 验证规则
    const rule模板 = {
        行业: [
            {
                required: true,
                message: "必填项",
                trigger: ["input", "blur"],
            },
        ],
        客户单位: [
            {
                required: true,
                message: "必填项",
                trigger: ["input", "blur"],
            },
        ],
        图片: [
            {
                required: true,
                message: "",
                trigger: ["input", "blur"],
            },
        ],
    }
    const rule = {}
    if (cfg.rule) {
        Object.assign(rule, cfg.rule)
    }

    watch(单项, (newValue, oldValue) => {
        // console.log(`单项变化 ing👇`)
        // console.log(`监听变化 👉`, 监听变化)
        // if (监听变化) {
        a.变化了 = true
        // }
        // 监听变化 = true
    })

    return {
        流程动作,
        元件袋,
        a,
        删,
        复制,
        新增子级,
        formRef,
        rule,
        保存,
        弹窗否,
        单项,
        初始化,
    }
}
